/*
 * @(#)RawBufferParser.java	1.37 02/08/21
 *
 * Copyright (c) 1996-2002 Sun Microsystems, Inc.  All rights reserved.
 */

package com.sun.media.parser;

import java.awt.Dimension;
import java.io.IOException;
import java.util.Vector;

import javax.media.Buffer;
import javax.media.Demultiplexer;
import javax.media.Format;
import javax.media.IncompatibleSourceException;
import javax.media.PlugInManager;
import javax.media.Time;
import javax.media.Track;
import javax.media.TrackListener;
import javax.media.format.AudioFormat;
import javax.media.format.VideoFormat;
import javax.media.protocol.BufferTransferHandler;
import javax.media.protocol.CaptureDevice;
import javax.media.protocol.DataSource;
import javax.media.protocol.PushBufferDataSource;
import javax.media.protocol.PushBufferStream;
import javax.media.protocol.SourceStream;

import com.sun.media.BasicPlugIn;
import com.sun.media.CircularBuffer;
import com.sun.media.rtp.Depacketizer;

/**
 * Parser for a raw stream of buffers from a PushBufferDataSource.
 */
public class RawBufferParser extends RawStreamParser {

    static final String NAMEBUFFER = "Raw video/audio buffer stream parser";

    private boolean started = false;

    // For comparing formats.
    static AudioFormat mpegAudio = new AudioFormat(AudioFormat.MPEG_RTP);
    static VideoFormat mpegVideo = new VideoFormat(VideoFormat.MPEG_RTP);
    static VideoFormat jpegVideo = new VideoFormat(VideoFormat.JPEG_RTP);
    static VideoFormat h261Video = new VideoFormat(VideoFormat.H261_RTP);
    static VideoFormat h263Video = new VideoFormat(VideoFormat.H263_RTP);
    static VideoFormat h263_1998Video = new VideoFormat(VideoFormat.H263_1998_RTP);

    public String getName() {
	return NAMEBUFFER;
    }

    public void setSource(DataSource source)
	throws IOException, IncompatibleSourceException {

	if (!(source instanceof PushBufferDataSource)) {
	    throw new IncompatibleSourceException("DataSource not supported: " + source);
	} else {
	    streams = ((PushBufferDataSource) source).getStreams();
	}

	if ( streams == null) {
	    throw new IOException("Got a null stream from the DataSource");
	}

	if (streams.length == 0) {
	    throw new IOException("Got a empty stream array from the DataSource");
	}

	if (!supports(streams))
	    throw new IncompatibleSourceException("DataSource not supported: " + source);

	this.source = source;
	this.streams = streams;
    }

    /**
     * Override this if the Parser has additional requirements
     * from the PushSourceStream
     */
    protected boolean supports(SourceStream[] streams) {
	return ( (streams[0] != null) &&
		 (streams[0] instanceof PushBufferStream) );
    }

    /**
     * Opens the plug-in software or hardware component and acquires
     * necessary resources. If all the needed resources could not be
     * acquired, it throws a ResourceUnavailableException. Data should not
     * be passed into the plug-in without first calling this method.
     */
    public void open() {
	if (tracks != null)
	    return;
	tracks = new Track[streams.length];
	for (int i = 0; i < streams.length; i++) {
	    tracks[i] = new FrameTrack(this, (PushBufferStream)streams[i], 1);
	}
    }

    public void close() {
	if (source != null) {
	    try {
		source.stop();
		// stop every tracks, so that readFrame() can be released.
		// close every tracks to unblock the transfer handlers.
		for (int i = 0; i < tracks.length; i++) {
		    ((FrameTrack)tracks[i]).stop();
		    ((FrameTrack)tracks[i]).close();
		}
		
		source.disconnect();
	    } catch (Exception e) {
		// Internal error?
	    }
	    source = null;
	}
	started = false;
    }

    /**
     */
    public Track [] getTracks() {
	for (int i = 0; i < tracks.length; i++)
	    ((FrameTrack)tracks[i]).parse();
	return tracks;
    }

    /**
     * Start the parser.
     */
    public void start() throws IOException {
	for (int i = 0; i < tracks.length; i++)
	    ((FrameTrack)tracks[i]).start();
	source.start();
	started = true;
    }

    /**
     * Stop the parser.
     */
    public void stop() {
	try {
	    source.stop();
	    // stop each of the tracks, so that readFrame can be released
	    for (int i = 0; i < tracks.length; i++)
		((FrameTrack)tracks[i]).stop();
	    
	} catch (Exception e) {
	    // Internal errors?
	}
	started = false;
    }

    /**
     * Resets the state of the plug-in. Typically at end of media or when media
     * is repositioned.
     */
    public void reset() {
	for (int i = 0; i < tracks.length; i++)
	    ((FrameTrack)tracks[i]).reset();
    }

    boolean isRTPFormat(Format fmt) {
	return  fmt != null &&
		fmt.getEncoding() != null &&
		(fmt.getEncoding().endsWith("rtp") ||
		 fmt.getEncoding().endsWith("RTP"));
    }


    /****************************************************************
     * Track class
     ****************************************************************/

    final int [] h261Widths = {176, 352};
    final int [] h261Heights = {144, 288};

    final int [] h263Widths = {0, 128, 176, 352, 704, 1408,0,0};
    final int [] h263Heights = {0, 96, 144, 288, 576, 1152,0,0};

    final float MPEGRateTbl[] = {
			0.0f, 23.976f, 24.f, 25.f, 29.97f,
			30.f, 50.f, 59.94f, 60.f
    };

    public static int[][] MPASampleTbl = {
			{ 22050, 24000, 16000, 0 },     // MPEG 2
			{ 44100, 48000, 32000, 0 }      // MPEG 1
    };

    
    class FrameTrack implements Track, BufferTransferHandler {

    Demultiplexer parser;
	PushBufferStream pbs;
	boolean enabled = true;
	CircularBuffer bufferQ;
	Format format = null;
	TrackListener listener;
	boolean stopped = true;
	boolean closed = false;
	boolean keyFrameFound = false;
        boolean checkDepacketizer = false;
        Depacketizer depacketizer = null;
	Object keyFrameLock = new Object();
	
	public FrameTrack(Demultiplexer parser, PushBufferStream pbs, int numOfBufs) {
	    this.pbs = pbs;
	    format = pbs.getFormat();
	    

	    if (source instanceof com.sun.media.protocol.DelegateDataSource ||
		!isRTPFormat(format)) {
		keyFrameFound = true;
	    }

	    bufferQ = new CircularBuffer(numOfBufs);
	    pbs.setTransferHandler(this);

	    //System.err.println("Track format is " + format);
	}

	public Format getFormat() {
	    return format;
	}

	public void setEnabled(boolean t) {
	    if (t)
		pbs.setTransferHandler(this);
	    else
		pbs.setTransferHandler(null);
	    enabled = t;
	}

	public boolean isEnabled() {
	    return enabled;
	}

	public Time getDuration() {
	    return parser.getDuration(); 
	}

	public Time getStartTime() {
	    return new Time(0);
	}


	public void setTrackListener(TrackListener l) {
	    listener = l;
	}

 
	/**
	 * Peek into the data stream to parse the data format.
	 */
	public void parse() {
	    try {
		synchronized (keyFrameLock) {
		    while (!keyFrameFound)
			keyFrameLock.wait();
		}
	    } catch (Exception e) {
	    }
	}


	private Depacketizer findDepacketizer(String name, Format input) {

	    Class cls;
	    Object obj;
		
	    try {
		cls = BasicPlugIn.getClassForName(name);
		obj = cls.newInstance();

		if (!(obj instanceof Depacketizer))
		    return null;

		Depacketizer dpktizer = (Depacketizer)obj;

		if (dpktizer.setInputFormat(input) == null)
		    return null;

		dpktizer.open();

		return dpktizer;

	    } catch (Exception e) {
	    } catch (Error e) { }

	    return null;
	}


	private boolean findKeyFrame(Buffer buf) {

	    if (!checkDepacketizer) {
		// Check to see if there's a depacketizer associated
		// with the format.  If so, we'll use it for parsing
		// the input.
		Vector pnames = PlugInManager.getPlugInList(buf.getFormat(),
					null, Depacketizer.DEPACKETIZER); 
		if (pnames.size() != 0) {
		    depacketizer = findDepacketizer((String)pnames.elementAt(0),
							buf.getFormat());
		}
		checkDepacketizer = true;
	    }

	    Format fmt = buf.getFormat();

	    if (fmt == null)
		return false;

	    if (fmt.getEncoding() == null) {
		synchronized (keyFrameLock) {
		    keyFrameFound = true;
		    keyFrameLock.notifyAll();
		}
		return true;
	    }

	    boolean rtn = true;

	    if (jpegVideo.matches(fmt))
		rtn = findJPEGKey(buf);
	    else if (h261Video.matches(fmt))
		rtn = findH261Key(buf);
	    else if (h263Video.matches(fmt))
		rtn = findH263Key(buf);
	    else if (h263_1998Video.matches(fmt))
		rtn = findH263_1998Key(buf);
	    else if (mpegVideo.matches(fmt))
		rtn = findMPEGKey(buf);
	    else if (mpegAudio.matches(fmt))
		rtn = findMPAKey(buf);
	    else if (depacketizer != null) {
		fmt = depacketizer.parse(buf);
		if (fmt != null) {
		    // Found the format.  We are done with
		    // the depacketizer.
		    format = fmt;
		    buf.setFormat(format);
		    depacketizer.close();
		    depacketizer = null;
		} else
		    rtn = false;
	    }

	    if (rtn) {
		synchronized (keyFrameLock) {
		    keyFrameFound = true;
		    keyFrameLock.notifyAll();
		}
	    }

	    return keyFrameFound;
	}


	/**
 	 * Parse the RTP/JPEG stream
	 * Code taken from com.sun.media.codec.video.jpeg.RTPDePacketizer.
	 */
	public boolean findJPEGKey(Buffer b) {

	    if ((b.getFlags() & Buffer.FLAG_RTP_MARKER) == 0)
		return false;

	    int width, height;
	    byte data[];

	    data = (byte[])b.getData();
	    width = (data[b.getOffset() + 6] & 0xff) * 8;
	    height = (data[b.getOffset() + 7] & 0xff) * 8;

	    format = new VideoFormat(VideoFormat.JPEG_RTP, 
				new Dimension(width, height),
				((VideoFormat)format).getMaxDataLength(),
				((VideoFormat)format).getDataType(),
				((VideoFormat)format).getFrameRate());

	    b.setFormat(format);
	    return true;
	}


	/**
 	 * Parse the RTP/H261 stream
         * Code taken from com.sun.media.codec.video.h261.NativeDecoder.
	 */
	public boolean findH261Key(Buffer b) {
	    int width, height, payloadLen, offset, skipBytes;
	    byte data[];

	    if ((data = (byte[])b.getData()) == null)
		return false;

	    offset = b.getOffset();

	    // Get to the actual h261 compressed payload
	    skipBytes = 4;

	    if ( (data[offset+skipBytes] != 0) || 
		 (data[offset+skipBytes+1] != 1) || 
		 ((data[offset+skipBytes+2] & 0xfc) != 0) ) {
		return false;
	    }

            int s = (data[offset+skipBytes+3]>>3)&0x01;
            width = h261Widths[s];
            height = h261Heights[s];
	    format = new VideoFormat(VideoFormat.H261_RTP, 
				new Dimension(width, height),
				((VideoFormat)format).getMaxDataLength(),
				((VideoFormat)format).getDataType(),
				((VideoFormat)format).getFrameRate());

	    b.setFormat(format);
	    return true;
	}


	/**
 	 * Parse the RTP/H263 stream
	 * Code taken from com.ibm.media.codec.video.h263.JavaDecoder.
	 */
	public boolean findH263Key(Buffer b) {
	    int width, height, payloadLen, offset;
	    byte data[];

	    if ((data = (byte[])b.getData()) == null)
		return false;

	    payloadLen = getH263PayloadHeaderLength(data, b.getOffset());
	    offset = b.getOffset();
	    if ((data[offset+payloadLen] != 0) || 
		(data[offset+payloadLen+1] != 0) ||
		((data[offset+payloadLen+2] & 0xfc) != 0x80))
		return false;

            int s = (data[offset+payloadLen+4] >> 2) & 0x7;
            width = h263Widths[s];
            height = h263Heights[s];

	    format = new VideoFormat(VideoFormat.H263_RTP, 
				new Dimension(width, height),
				((VideoFormat)format).getMaxDataLength(),
				((VideoFormat)format).getDataType(),
				((VideoFormat)format).getFrameRate());

	    b.setFormat(format);
	    return true;
	}


	int getH263PayloadHeaderLength(byte[] input,int offset) {

	    int l = 0;
	    byte b = input[offset];

	    if ( (b & 0x80) != 0) { //mode B or C
		if ((b & 0x40) != 0) //mode C
		    l = 12;
		else //mode B
		    l = 8;
	    } else { //mode A
		l = 4;
	    }

	    return l;
	}


	/**
 	 * Parse the RTP/H263-1998 stream
	 * Code taken from com.sun.media.codec.video.h263.NativeDecoder.
	 */
	public boolean findH263_1998Key(Buffer b) {
	    int width, height, payloadLen, offset;
	    byte data[];
            int s = -1;
	    int picOffset = -1;

	    if ((data = (byte[])b.getData()) == null)
		return false;

	    offset = b.getOffset();

	    // 2 bytes for H263-1998 header + pLen from header
	    payloadLen = 2 + (((data[offset] & 0x01) << 5)
					| ((data[offset+1] & 0xf8) >> 3));
	    if ( (data[offset] & 0x02) != 0) { // Video Redundancy present
		payloadLen++;
	    }

	    picOffset = -1;

	    if (payloadLen > 5) {
		// Use PIC header in payload header
		if ( ((data[offset] & 0x02) == 0x02)
				&& ((data[offset+3] & 0xfc) == 0x80)) {
			picOffset = offset + 3;
		} else if ((data[offset+2] & 0xfc) == 0x80) {
			picOffset = offset + 2;
		}
	    } else if ( ((data[offset] & 0x04) == 0x04)
			&& ((data[offset+payloadLen] & 0xfc) == 0x80)) {
		    picOffset = offset + payloadLen;
	    }

	    if (picOffset < 0)
		return false;

	    s = (data[picOffset+2] >> 2) & 0x7;
	    if (s == 7) {
		// Extended PTYPE, picture size is in the extension
		// if UFEP = 001
		if (((data[picOffset+3] >> 1) & 0x07) == 1) {
		    s = ((data[picOffset+3] << 2) & 0x04) |
				((data[picOffset+4] >> 6) & 0x03);
		} else {
		    return false;	// picture type not present
		}
	    }
	    if (s < 0)
		return false;

            width = h263Widths[s];
            height = h263Heights[s];

	    format = new VideoFormat(VideoFormat.H263_1998_RTP, 
				new Dimension(width, height),
				((VideoFormat)format).getMaxDataLength(),
				((VideoFormat)format).getDataType(),
				((VideoFormat)format).getFrameRate());
	    b.setFormat(format);
	    return true;
	}


	/**
 	 * Parse the RTP/MPEG video stream
	 * Code taken from com.sun.media.codec.video.mpeg.DePacketizer.
	 */
	public boolean findMPEGKey(Buffer b) {
	    int width, height;
	    float frameRate;
	    byte data[];

	    if ((data = (byte[])b.getData()) == null) {
		return false;
	    }

	    int off = b.getOffset();
	    if (b.getLength() < 12) {
		return false;		// can't contain MPEG sequence header
	    }

	    if ((data[off+2] & 0x20) != 0x20) {
		return false;		// doesn't contain MPEG sequence header
	    }

	    if (data[off+4] != 0
			|| data[off+5] != 0
			|| data[off+6] != 1
			|| (data[off+7] & 0xff) != 0xb3) {
		return false;	// doesn't start with MPEG sequence header
	    }

	    int frix = (data[off+11] & 0x0f);
	    if (frix == 0 || frix > 8) {
		return false;			// not a valid frame rate
	    }

	    width = ((data[off+8] & 0xff) << 4) |
						((data[off+9] & 0xf0) >> 4);
	    height = ((data[off+9] & 0x0f) << 8) | (data[off+10] & 0xff);
	    frameRate = MPEGRateTbl[frix];

	    format = new VideoFormat(VideoFormat.MPEG_RTP, 
				new Dimension(width, height),
				((VideoFormat)format).getMaxDataLength(),
				((VideoFormat)format).getDataType(),
				frameRate);

	    b.setFormat(format);
	    return true;
	}


	/**
 	 * Parse the RTP/MPEG audio stream
	 * Code taken from com.sun.media.codec.audio.mpa.DePacketizer.
	 */
	public boolean findMPAKey(Buffer b) {
	    int channels;
	    double sampleRate;
	    byte data[];

	    if ((data = (byte[])b.getData()) == null)
		return false;

	    int off = b.getOffset();
	    if (b.getLength() < 8)
		return false;		// doesn't contain MPA header

	    if (data[off+2] != 0 || data[off+3] != 0)
		return false;		// frame continuation

	    off += 4;		// skip RTP header to get to MPA header
	    if ((data[off] & 0xff) != 0xff
			|| (data[off+1] & 0xf6) <= 0xf0
			|| (data[off+2] & 0xf0) == 0xf0
			|| (data[off+2] & 0x0c) == 0x0c
			|| (data[off+3] & 0x03) == 0x02)
		return false;	// doesn't start with a valid MPA header

	    int id = (data[off+1] >> 3) & 1;	// MPEG1 or MPEG2
	    int six = (data[off+2] >> 2) & 3;
	    channels = (((data[off+3] >> 6) & 3) == 3) ? 1 : 2;
	    sampleRate = MPASampleTbl[id][six];

	    format = new AudioFormat(AudioFormat.MPEG_RTP, 
				sampleRate, 16, channels,
				AudioFormat.LITTLE_ENDIAN,
				AudioFormat.SIGNED);

	    b.setFormat(format);
	    return true;
	}


	public void stop(){
	    // we basically need to ensure that readFrame will return
	    // immediately.and also make sure that if it is called in
	    // the stopped state, it returns w/o blocking.
	    synchronized (bufferQ){
		stopped = true;
		bufferQ.notifyAll();
	    }
	}

	public void start(){
	    // we need to ensure that readFrame is returned to its
	    // original state and does not return w/o blocking.
	    synchronized (bufferQ){
		stopped = false;
		if (source instanceof CaptureDevice) {
		    // Flush the buffer Q.
		    while (bufferQ.canRead()) {
			bufferQ.read();
			bufferQ.readReport();
		    }
		}
		bufferQ.notifyAll();
	    }
	}

	public void close() {
	    // Unblock the transfer handlers.
	    setEnabled(false);
	    synchronized (bufferQ) {
		closed = true;
		bufferQ.notifyAll();
	    }
	}

	public void reset() {
	}

	public void readFrame(Buffer buffer) {
		
		// Retrieve a filled buffer.
	    if (stopped) {
	    buffer.setDiscard(true);
		buffer.setFormat(format);
		return;
	    }
	    //System.out.println("Proxy-frame-RawBufferParser: prima del wait:"+System.currentTimeMillis());
	    Buffer filled;
	    synchronized (bufferQ) {
	    while (!bufferQ.canRead()) {
		    try {
			bufferQ.wait();
			if (stopped){
			    buffer.setDiscard(true);
			    buffer.setFormat(format);
			    return;
			}
		    } catch (Exception e) {}
		}
		filled = bufferQ.read();
		
	    }
	    //System.out.println("Proxy-frame-RawBufferParser: dopo del wait:"+System.currentTimeMillis());
	    
	    // Copy all the attributes from filled to buffer.
	    Object hdr = buffer.getHeader();
	    buffer.copy(filled, true);
	    filled.setHeader(hdr);
	    

	    //if ((buffer.getFlags() & Buffer.FLAG_RTP_MARKER) != 0)
	    //System.err.println("RBP: TS: " + buffer.getTimeStamp());

	    // Update the saved format.
	    format = filled.getFormat();

	    synchronized (bufferQ) {
		bufferQ.readReport();
		bufferQ.notifyAll();
		
	    }
	}

	public int mapTimeToFrame(Time t) {
	    return -1;
	}

	public Time mapFrameToTime(int frameNumber) {
	    return new Time(0);
	}

	public void transferData(PushBufferStream pbs) {
		
		// Retrieve an empty buffer for the PSS to write into.
	    Buffer buffer;
	    synchronized (bufferQ) {
		while (!bufferQ.canWrite() && !closed) {
		    try {
			bufferQ.wait();
		    } catch (Exception e) {}
		}
		// If source is null, the data source has been closed.
		if (closed)
		    return;
		buffer = bufferQ.getEmptyBuffer();
	    }

	    try {
		pbs.read(buffer);
	    } catch (IOException e) {
		buffer.setDiscard(true);
	    }

	    // Until we find the first key frame, we won't
	    // add it to the buffer queue.
	    if (!keyFrameFound && !findKeyFrame(buffer)) {
		synchronized (bufferQ) {
		    // Discard that buffer.
		    bufferQ.writeReport();
		    bufferQ.read();
		    bufferQ.readReport();
		}
		return;
	    }

	    // Put the filled buffer back to the queue for consumption.
	    synchronized (bufferQ) {
		bufferQ.writeReport();
		bufferQ.notifyAll();
	    }
	}
    }
}

